namespace java.io
{
	/// <summary>
	/// This abstract class is the superclass of all classes representing
	/// an input stream of bytes.
	/// </summary>
	/// <remarks>
	/// This abstract class is the superclass of all classes representing
	/// an input stream of bytes.
	/// <p> Applications that need to define a subclass of <code>InputStream</code>
	/// must always provide a method that returns the next byte of input.
	/// </remarks>
	/// <author>Arthur van Hoff</author>
	/// <version>1.52, 06/07/06</version>
	/// <seealso cref="java.io.BufferedInputStream">java.io.BufferedInputStream</seealso>
	/// <seealso cref="java.io.ByteArrayInputStream">java.io.ByteArrayInputStream</seealso>
	/// <seealso cref="java.io.DataInputStream">java.io.DataInputStream</seealso>
	/// <seealso cref="java.io.FilterInputStream">java.io.FilterInputStream</seealso>
	/// <seealso cref="java.io.InputStream.read()">java.io.InputStream.read()</seealso>
	/// <seealso cref="java.io.OutputStream">java.io.OutputStream</seealso>
	/// <seealso cref="java.io.PushbackInputStream">java.io.PushbackInputStream</seealso>
	/// <since>JDK1.0</since>
	public abstract class InputStream : Closeable
	{
		private const int SKIP_BUFFER_SIZE = 2048;

		private static byte[] skipBuffer;

		// SKIP_BUFFER_SIZE is used to determine the size of skipBuffer
		// skipBuffer is initialized in skip(long), if needed.
		/// <summary>Reads the next byte of data from the input stream.</summary>
		/// <remarks>
		/// Reads the next byte of data from the input stream. The value byte is
		/// returned as an <code>int</code> in the range <code>0</code> to
		/// <code>255</code>. If no byte is available because the end of the stream
		/// has been reached, the value <code>-1</code> is returned. This method
		/// blocks until input data is available, the end of the stream is detected,
		/// or an exception is thrown.
		/// <p> A subclass must provide an implementation of this method.
		/// </remarks>
		/// <returns>
		/// the next byte of data, or <code>-1</code> if the end of the
		/// stream is reached.
		/// </returns>
		/// <exception>
		/// IOException
		/// if an I/O error occurs.
		/// </exception>
		/// <exception cref="System.IO.IOException"></exception>
		public abstract int read();

		/// <summary>
		/// Reads some number of bytes from the input stream and stores them into
		/// the buffer array <code>b</code>.
		/// </summary>
		/// <remarks>
		/// Reads some number of bytes from the input stream and stores them into
		/// the buffer array <code>b</code>. The number of bytes actually read is
		/// returned as an integer.  This method blocks until input data is
		/// available, end of file is detected, or an exception is thrown.
		/// <p> If the length of <code>b</code> is zero, then no bytes are read and
		/// <code>0</code> is returned; otherwise, there is an attempt to read at
		/// least one byte. If no byte is available because the stream is at the
		/// end of the file, the value <code>-1</code> is returned; otherwise, at
		/// least one byte is read and stored into <code>b</code>.
		/// <p> The first byte read is stored into element <code>b[0]</code>, the
		/// next one into <code>b[1]</code>, and so on. The number of bytes read is,
		/// at most, equal to the length of <code>b</code>. Let <i>k</i> be the
		/// number of bytes actually read; these bytes will be stored in elements
		/// <code>b[0]</code> through <code>b[</code><i>k</i><code>-1]</code>,
		/// leaving elements <code>b[</code><i>k</i><code>]</code> through
		/// <code>b[b.length-1]</code> unaffected.
		/// <p> The <code>read(b)</code> method for class <code>InputStream</code>
		/// has the same effect as: <pre><code> read(b, 0, b.length) </code></pre>
		/// </remarks>
		/// <param name="b">the buffer into which the data is read.</param>
		/// <returns>
		/// the total number of bytes read into the buffer, or
		/// <code>-1</code> is there is no more data because the end of
		/// the stream has been reached.
		/// </returns>
		/// <exception>
		/// IOException
		/// If the first byte cannot be read for any reason
		/// other than the end of the file, if the input stream has been closed, or
		/// if some other I/O error occurs.
		/// </exception>
		/// <exception>
		/// NullPointerException
		/// if <code>b</code> is <code>null</code>.
		/// </exception>
		/// <seealso cref="java.io.InputStream.read(byte[], int, int)">java.io.InputStream.read(byte[], int, int)
		/// 	</seealso>
		/// <exception cref="System.IO.IOException"></exception>
		public virtual int read(byte[] b)
		{
			return read(b, 0, b.Length);
		}

		/// <summary>
		/// Reads up to <code>len</code> bytes of data from the input stream into
		/// an array of bytes.
		/// </summary>
		/// <remarks>
		/// Reads up to <code>len</code> bytes of data from the input stream into
		/// an array of bytes.  An attempt is made to read as many as
		/// <code>len</code> bytes, but a smaller number may be read.
		/// The number of bytes actually read is returned as an integer.
		/// <p> This method blocks until input data is available, end of file is
		/// detected, or an exception is thrown.
		/// <p> If <code>len</code> is zero, then no bytes are read and
		/// <code>0</code> is returned; otherwise, there is an attempt to read at
		/// least one byte. If no byte is available because the stream is at end of
		/// file, the value <code>-1</code> is returned; otherwise, at least one
		/// byte is read and stored into <code>b</code>.
		/// <p> The first byte read is stored into element <code>b[off]</code>, the
		/// next one into <code>b[off+1]</code>, and so on. The number of bytes read
		/// is, at most, equal to <code>len</code>. Let <i>k</i> be the number of
		/// bytes actually read; these bytes will be stored in elements
		/// <code>b[off]</code> through <code>b[off+</code><i>k</i><code>-1]</code>,
		/// leaving elements <code>b[off+</code><i>k</i><code>]</code> through
		/// <code>b[off+len-1]</code> unaffected.
		/// <p> In every case, elements <code>b[0]</code> through
		/// <code>b[off]</code> and elements <code>b[off+len]</code> through
		/// <code>b[b.length-1]</code> are unaffected.
		/// <p> The <code>read(b,</code> <code>off,</code> <code>len)</code> method
		/// for class <code>InputStream</code> simply calls the method
		/// <code>read()</code> repeatedly. If the first such call results in an
		/// <code>IOException</code>, that exception is returned from the call to
		/// the <code>read(b,</code> <code>off,</code> <code>len)</code> method.  If
		/// any subsequent call to <code>read()</code> results in a
		/// <code>IOException</code>, the exception is caught and treated as if it
		/// were end of file; the bytes read up to that point are stored into
		/// <code>b</code> and the number of bytes read before the exception
		/// occurred is returned. The default implementation of this method blocks
		/// until the requested amount of input data <code>len</code> has been read,
		/// end of file is detected, or an exception is thrown. Subclasses are encouraged
		/// to provide a more efficient implementation of this method.
		/// </remarks>
		/// <param name="b">the buffer into which the data is read.</param>
		/// <param name="off">
		/// the start offset in array <code>b</code>
		/// at which the data is written.
		/// </param>
		/// <param name="len">the maximum number of bytes to read.</param>
		/// <returns>
		/// the total number of bytes read into the buffer, or
		/// <code>-1</code> if there is no more data because the end of
		/// the stream has been reached.
		/// </returns>
		/// <exception>
		/// IOException
		/// If the first byte cannot be read for any reason
		/// other than end of file, or if the input stream has been closed, or if
		/// some other I/O error occurs.
		/// </exception>
		/// <exception>
		/// NullPointerException
		/// If <code>b</code> is <code>null</code>.
		/// </exception>
		/// <exception>
		/// IndexOutOfBoundsException
		/// If <code>off</code> is negative,
		/// <code>len</code> is negative, or <code>len</code> is greater than
		/// <code>b.length - off</code>
		/// </exception>
		/// <seealso cref="java.io.InputStream.read()">java.io.InputStream.read()</seealso>
		/// <exception cref="System.IO.IOException"></exception>
		public virtual int read(byte[] b, int off, int len)
		{
			if (b == null)
			{
				throw new System.ArgumentNullException();
			}
			else
			{
				if (off < 0 || len < 0 || len > b.Length - off)
				{
					throw new System.IndexOutOfRangeException();
				}
				else
				{
					if (len == 0)
					{
						return 0;
					}
				}
			}
			int c = read();
			if (c == -1)
			{
				return -1;
			}
			b[off] = (byte)c;
			int i = 1;
			try
			{
				for (; i < len; i++)
				{
					c = read();
					if (c == -1)
					{
						break;
					}
					b[off + i] = (byte)c;
				}
			}
			catch (System.IO.IOException)
			{
			}
			return i;
		}

		/// <summary>
		/// Skips over and discards <code>n</code> bytes of data from this input
		/// stream.
		/// </summary>
		/// <remarks>
		/// Skips over and discards <code>n</code> bytes of data from this input
		/// stream. The <code>skip</code> method may, for a variety of reasons, end
		/// up skipping over some smaller number of bytes, possibly <code>0</code>.
		/// This may result from any of a number of conditions; reaching end of file
		/// before <code>n</code> bytes have been skipped is only one possibility.
		/// The actual number of bytes skipped is returned.  If <code>n</code> is
		/// negative, no bytes are skipped.
		/// <p> The <code>skip</code> method of this class creates a
		/// byte array and then repeatedly reads into it until <code>n</code> bytes
		/// have been read or the end of the stream has been reached. Subclasses are
		/// encouraged to provide a more efficient implementation of this method.
		/// For instance, the implementation may depend on the ability to seek.
		/// </remarks>
		/// <param name="n">the number of bytes to be skipped.</param>
		/// <returns>the actual number of bytes skipped.</returns>
		/// <exception>
		/// IOException
		/// if the stream does not support seek,
		/// or if some other I/O error occurs.
		/// </exception>
		/// <exception cref="System.IO.IOException"></exception>
		public virtual long skip(long n)
		{
			long remaining = n;
			int nr;
			if (skipBuffer == null)
			{
				skipBuffer = new byte[SKIP_BUFFER_SIZE];
			}
			byte[] localSkipBuffer = skipBuffer;
			if (n <= 0)
			{
				return 0;
			}
			while (remaining > 0)
			{
				nr = read(localSkipBuffer, 0, (int)System.Math.Min(SKIP_BUFFER_SIZE, remaining));
				if (nr < 0)
				{
					break;
				}
				remaining -= nr;
			}
			return n - remaining;
		}

		/// <summary>
		/// Returns an estimate of the number of bytes that can be read (or
		/// skipped over) from this input stream without blocking by the next
		/// invocation of a method for this input stream.
		/// </summary>
		/// <remarks>
		/// Returns an estimate of the number of bytes that can be read (or
		/// skipped over) from this input stream without blocking by the next
		/// invocation of a method for this input stream. The next invocation
		/// might be the same thread or another thread.  A single read or skip of this
		/// many bytes will not block, but may read or skip fewer bytes.
		/// <p> Note that while some implementations of
		/// <code>InputStream</code>
		/// will return
		/// the total number of bytes in the stream, many will not.  It is
		/// never correct to use the return value of this method to allocate
		/// a buffer intended to hold all data in this stream.
		/// <p> A subclass' implementation of this method may choose to throw an
		/// <see cref="System.IO.IOException">System.IO.IOException</see>
		/// if this input stream has been closed by
		/// invoking the
		/// <see cref="close()">close()</see>
		/// method.
		/// <p> The
		/// <code>available</code>
		/// method for class
		/// <code>InputStream</code>
		/// always
		/// returns
		/// <code>0</code>
		/// .
		/// <p> This method should be overridden by subclasses.
		/// </remarks>
		/// <returns>
		/// an estimate of the number of bytes that can be read (or skipped
		/// over) from this input stream without blocking or
		/// <code>0</code>
		/// when
		/// it reaches the end of the input stream.
		/// </returns>
		/// <exception>
		/// IOException
		/// if an I/O error occurs.
		/// </exception>
		/// <exception cref="System.IO.IOException"></exception>
		public virtual int available()
		{
			return 0;
		}

		/// <summary>
		/// Closes this input stream and releases any system resources associated
		/// with the stream.
		/// </summary>
		/// <remarks>
		/// Closes this input stream and releases any system resources associated
		/// with the stream.
		/// <p> The <code>close</code> method of <code>InputStream</code> does
		/// nothing.
		/// </remarks>
		/// <exception>
		/// IOException
		/// if an I/O error occurs.
		/// </exception>
		/// <exception cref="System.IO.IOException"></exception>
		public virtual void close()
		{
		}

		/// <summary>Marks the current position in this input stream.</summary>
		/// <remarks>
		/// Marks the current position in this input stream. A subsequent call to
		/// the <code>reset</code> method repositions this stream at the last marked
		/// position so that subsequent reads re-read the same bytes.
		/// <p> The <code>readlimit</code> arguments tells this input stream to
		/// allow that many bytes to be read before the mark position gets
		/// invalidated.
		/// <p> The general contract of <code>mark</code> is that, if the method
		/// <code>markSupported</code> returns <code>true</code>, the stream somehow
		/// remembers all the bytes read after the call to <code>mark</code> and
		/// stands ready to supply those same bytes again if and whenever the method
		/// <code>reset</code> is called.  However, the stream is not required to
		/// remember any data at all if more than <code>readlimit</code> bytes are
		/// read from the stream before <code>reset</code> is called.
		/// <p> Marking a closed stream should not have any effect on the stream.
		/// <p> The <code>mark</code> method of <code>InputStream</code> does
		/// nothing.
		/// </remarks>
		/// <param name="readlimit">
		/// the maximum limit of bytes that can be read before
		/// the mark position becomes invalid.
		/// </param>
		/// <seealso cref="java.io.InputStream.reset()">java.io.InputStream.reset()</seealso>
		public virtual void mark(int readlimit)
		{
			lock (this)
			{
			}
		}

		/// <summary>
		/// Repositions this stream to the position at the time the
		/// <code>mark</code> method was last called on this input stream.
		/// </summary>
		/// <remarks>
		/// Repositions this stream to the position at the time the
		/// <code>mark</code> method was last called on this input stream.
		/// <p> The general contract of <code>reset</code> is:
		/// <p><ul>
		/// <li> If the method <code>markSupported</code> returns
		/// <code>true</code>, then:
		/// <ul><li> If the method <code>mark</code> has not been called since
		/// the stream was created, or the number of bytes read from the stream
		/// since <code>mark</code> was last called is larger than the argument
		/// to <code>mark</code> at that last call, then an
		/// <code>IOException</code> might be thrown.
		/// <li> If such an <code>IOException</code> is not thrown, then the
		/// stream is reset to a state such that all the bytes read since the
		/// most recent call to <code>mark</code> (or since the start of the
		/// file, if <code>mark</code> has not been called) will be resupplied
		/// to subsequent callers of the <code>read</code> method, followed by
		/// any bytes that otherwise would have been the next input data as of
		/// the time of the call to <code>reset</code>. </ul>
		/// <li> If the method <code>markSupported</code> returns
		/// <code>false</code>, then:
		/// <ul><li> The call to <code>reset</code> may throw an
		/// <code>IOException</code>.
		/// <li> If an <code>IOException</code> is not thrown, then the stream
		/// is reset to a fixed state that depends on the particular type of the
		/// input stream and how it was created. The bytes that will be supplied
		/// to subsequent callers of the <code>read</code> method depend on the
		/// particular type of the input stream. </ul></ul>
		/// <p>The method <code>reset</code> for class <code>InputStream</code>
		/// does nothing except throw an <code>IOException</code>.
		/// </remarks>
		/// <exception>
		/// IOException
		/// if this stream has not been marked or if the
		/// mark has been invalidated.
		/// </exception>
		/// <seealso cref="java.io.InputStream.mark(int)">java.io.InputStream.mark(int)</seealso>
		/// <seealso cref="System.IO.IOException">System.IO.IOException</seealso>
		public virtual void reset()
		{
			lock (this)
			{
				throw new System.IO.IOException("mark/reset not supported");
			}
		}

		/// <summary>
		/// Tests if this input stream supports the <code>mark</code> and
		/// <code>reset</code> methods.
		/// </summary>
		/// <remarks>
		/// Tests if this input stream supports the <code>mark</code> and
		/// <code>reset</code> methods. Whether or not <code>mark</code> and
		/// <code>reset</code> are supported is an invariant property of a
		/// particular input stream instance. The <code>markSupported</code> method
		/// of <code>InputStream</code> returns <code>false</code>.
		/// </remarks>
		/// <returns>
		/// <code>true</code> if this stream instance supports the mark
		/// and reset methods; <code>false</code> otherwise.
		/// </returns>
		/// <seealso cref="java.io.InputStream.mark(int)">java.io.InputStream.mark(int)</seealso>
		/// <seealso cref="java.io.InputStream.reset()">java.io.InputStream.reset()</seealso>
		public virtual bool markSupported()
		{
			return false;
		}
	}
}
